﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; 
using ServiceStack.Redis;

namespace CacheStrategy
{
        public class RedisHelper
        {
            private static string RedisPath = System.Configuration.ConfigurationSettings.AppSettings["RedisPath"];

            #region -- 连接信息 --
            //127.0.0.1:6379
            public static PooledRedisClientManager prcm = CreateManager(new string[] { RedisPath }, new string[] { RedisPath });
            private static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
            {
                // 支持读写分离，均衡负载 
                return new PooledRedisClientManager(readWriteHosts, readOnlyHosts, new RedisClientManagerConfig
                {
                    MaxWritePoolSize = 5, // “写”链接池链接数 
                    MaxReadPoolSize = 5, // “读”链接池链接数 
                    AutoStart = true,
                });
            }
            #endregion

            #region 单体操作
            /// <summary>
            /// 设置单个实体
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public static bool Single_Set_Itme<T>(string key, T t)
            {
                try
                {
                    using (IRedisClient redis = prcm.GetClient())
                    {
                        return redis.Set<T>(key, t);
                    }
                }
                catch { }
                return false;
            }

            public static bool Single_Set_Itme<T>(string key, T t,TimeSpan ts)
            {
                try
                {
                    using (IRedisClient redis = prcm.GetClient())
                    {
                        return redis.Set<T>(key, t, ts);
                    }
                }
                catch { }
                return false;
            }
            /// <summary>
            /// 获取单体
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public static T Single_Get_Itme<T>(string key) where T : class
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return redis.Get<T>(key);
                }
            }

            /// <summary>
            /// 移除单体
            /// </summary>
            /// <param name="key"></param>
            public static bool Single_Remove_Itme(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return redis.Remove(key);
                }
            }

            public static bool Exist(string key)
            {

                using (IRedisClient redis = prcm.GetClient())
                {
                    return redis.GetAllKeys().Contains(key);
                }
            }
            #endregion

            #region List集合
            /// <summary>
            /// 新增一个集合
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            public static void List_AddJson<T>(string key, T t)
            {
                using (IRedisClient redis = prcm.GetClient())
                {

                    string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                    redis.AddItemToList(key, value);
                }
            }


            /// <summary>
            /// 新增一个集合
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            public static void List_Add<T>(string key, T t)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var redisTypedClient = redis.GetTypedClient<T>();
                    redisTypedClient.AddItemToList(redisTypedClient.Lists[key], t);
                }
            }


            /// <summary>
            /// 移除单个
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public static bool List_Remove<T>(string key, T t)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var redisTypedClient = redis.GetTypedClient<T>();
                    return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;
                }
            }
            /// <summary>
            /// 移除所有
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public static void List_RemoveAll<T>(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var redisTypedClient = redis.GetTypedClient<T>();
                    redisTypedClient.Lists[key].RemoveAll();
                }
            }
            /// <summary>
            /// 获取总数
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public static int List_Count(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return (int)redis.GetListCount(key);
                }
            }
            /// <summary>
            /// 获取范围
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="start">开始</param>
            /// <param name="count">数量</param>
            /// <returns></returns>
            public static List<T> List_GetRange<T>(string key, int start, int count)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var c = redis.GetTypedClient<T>();
                    return c.Lists[key].GetRange(start, start + count - 1);
                }
            }

            /// <summary>
            /// 获取所有
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public static List<T> List_GetList<T>(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var c = redis.GetTypedClient<T>();
                    if (c.Lists[key].Count==0)
                    {
                        return null;
                    }
                    return c.Lists[key].GetRange(0, c.Lists[key].Count);
                }
            }
            /// <summary>
            /// 获取所有集合
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="pageIndex"></param>
            /// <param name="pageSize"></param>
            /// <returns></returns>
            public static List<T> List_GetList<T>(string key, int pageIndex, int pageSize)
            {
                int start = pageSize * (pageIndex - 1);
                return List_GetRange<T>(key, start, pageSize);
            }

            /// <summary>
            /// 设置缓存过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="datetime"></param>
            public static void List_SetExpire(string key, DateTime datetime)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    redis.ExpireEntryAt(key, datetime);
                }
            }
            #endregion

            #region Set信息
            /// <summary>
            /// 新增
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            public static void Set_Add<T>(string key, T t)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var redisTypedClient = redis.GetTypedClient<T>();
                    redisTypedClient.Sets[key].Add(t);

                }
            }
            /// <summary>
            /// 包含
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public static bool Set_Contains<T>(string key, T t)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var redisTypedClient = redis.GetTypedClient<T>();
                    return redisTypedClient.Sets[key].Contains(t);
                }
            }
            /// <summary>
            /// 删除
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public static bool Set_Remove<T>(string key, T t)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var redisTypedClient = redis.GetTypedClient<T>();
                    return redisTypedClient.Sets[key].Remove(t);
                }
            }
            public static int Set_Count(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return (int)redis.GetSetCount(key); 
                }
            }
            #endregion

            #region Hash

            /// <summary>
            /// 判断某个数据是否已经被缓存
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public static bool Hash_Exist<T>(string key, string dataKey)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return redis.HashContainsEntry(key, dataKey);
                }
            }

            /// <summary>
            /// 存储数据到hash表
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public static bool Hash_Set<T>(string key, string dataKey, T t)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                    return redis.SetEntryInHash(key, dataKey, value);
                }
            }
            /// <summary>
            /// 移除hash中的某值
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public static bool Hash_Remove(string key, string dataKey)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return redis.RemoveEntryFromHash(key, dataKey);
                }
            }
            /// <summary>
            /// 移除整个hash
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public static bool Hash_Remove(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return redis.Remove(key);
                }
            }
            /// <summary>
            /// 从hash表获取数据
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public static T Hash_Get<T>(string key, string dataKey)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    string value = redis.GetValueFromHash(key, dataKey);
                    return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(value);
                }
            }
            /// <summary>
            /// 获取整个hash的数据
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public static List<T> Hash_GetAll<T>(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var list = redis.GetHashValues(key);
                    if (list != null && list.Count > 0)
                    {
                        List<T> result = new List<T>();
                        foreach (var item in list)
                        {
                            var value = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                            result.Add(value);
                        }
                        return result;
                    }
                    return null;
                }
            }
            /// <summary>
            /// 设置缓存过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="datetime"></param>
            public static void Hash_SetExpire(string key, DateTime datetime)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    redis.ExpireEntryAt(key, datetime);
                }
            }

            #endregion

            #region SortedSet 分类
            /// <summary>
            ///  添加数据到 SortedSet
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            /// <param name="score"></param>
            public static bool SortedSet_Add<T>(string key, T t, double score)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                    return redis.AddItemToSortedSet(key, value, score);
                }
            }
            /// <summary>
            /// 移除数据从SortedSet
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public static bool SortedSet_Remove<T>(string key, T t)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                    return redis.RemoveItemFromSortedSet(key, value);
                }
            }
            /// <summary>
            /// 修剪SortedSet
            /// </summary>
            /// <param name="key"></param>
            /// <param name="size">保留的条数</param>
            /// <returns></returns>
            public static int SortedSet_Trim(string key, int size)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return (int)redis.RemoveRangeFromSortedSet(key, size, 9999999);
                }
            }
            /// <summary>
            /// 获取SortedSet的长度
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public static int SortedSet_Count(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return (int)redis.GetSortedSetCount(key);
                }
            }

            /// <summary>
            /// 获取SortedSet的分页数据
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="pageIndex"></param>
            /// <param name="pageSize"></param>
            /// <returns></returns>
            public static List<T> SortedSet_GetList<T>(string key, int pageIndex, int pageSize)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var list = redis.GetRangeFromSortedSet(key, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);
                    if (list != null && list.Count > 0)
                    {
                        List<T> result = new List<T>();
                        foreach (var item in list)
                        {
                            var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                            result.Add(data);
                        }
                        return result;
                    }
                }
                return null;
            }


            /// <summary>
            /// 获取SortedSet的全部数据
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="pageIndex"></param>
            /// <param name="pageSize"></param>
            /// <returns></returns>
            public static List<T> SortedSet_GetListALL<T>(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    var list = redis.GetRangeFromSortedSet(key, 0, 9999999);
                    if (list != null && list.Count > 0)
                    {
                        List<T> result = new List<T>();
                        foreach (var item in list)
                        {
                            var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                            result.Add(data);
                        }
                        return result;
                    }
                }
                return null;
            }
            /// <summary>
            /// 获取SortedSet的全部数据
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="pageIndex"></param>
            /// <param name="pageSize"></param>
            /// <returns></returns>
            public static List<T> SortedSet_GetListSearchKeys<T>(string key)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    List<string> keys = redis.GetAllKeys();
                    List<T> result = new List<T>();
                    keys.ForEach(k =>
                    {
                        if (k.Contains(key))
                        {
                            var item = redis.Get<T>(k);
                            //var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item.ToString());
                            result.Add(item);
                        }
                    });
                    return result;
                }
                //return null;
            }
            /// <summary>
            /// 设置缓存过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="datetime"></param>
            public static void SortedSet_SetExpire(string key, DateTime datetime)
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    redis.ExpireEntryAt(key, datetime);
                }
            }


            #endregion


        
    }

}
